home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / gdb-4.5 / dist / gdb / remote-mm.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-03-18  |  50.2 KB  |  1,703 lines
  1. /* Remote debugging interface for Am290*0 running MiniMON monitor, for GDB.
  2.    Copyright 1990, 1991, 1992 Free Software Foundation, Inc.
  3.    Originally written by Daniel Mann at AMD.
  4.  
  5. This file is part of GDB.
  6.  
  7. This program is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 2 of the License, or
  10. (at your option) any later version.
  11.  
  12. This program is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. GNU General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with this program; if not, write to the Free Software
  19. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20.  
  21. /* This is like remote.c but ecpects MiniMON to be running on the Am29000 
  22.    target hardware.
  23.  - David Wood (wood@lab.ultra.nyu.edu) at New York University adapted this
  24.     file to gdb 3.95.  I was unable to get this working on sun3os4
  25.     with termio, only with sgtty.  Because we are only attempting to
  26.     use this module to debug our kernel, which is already loaded when
  27.     gdb is started up, I did not code up the file downloading facilities.  
  28.     As a result this module has only the stubs to download files. 
  29.     You should get tagged at compile time if you need to make any 
  30.     changes/additions.  */
  31.  
  32. #include "defs.h"
  33. #include "inferior.h"
  34. #include "wait.h"
  35. #include "value.h"
  36. #include <ctype.h>
  37. #include <fcntl.h>
  38. #include <signal.h>
  39. #include <errno.h>
  40. #include <string.h>
  41. #include "terminal.h"
  42. #include "minimon.h"
  43. #include "target.h"
  44.  
  45. /* Offset of member MEMBER in a struct of type TYPE.  */
  46. #define offsetof(TYPE, MEMBER) ((int) &((TYPE *)0)->MEMBER)
  47.  
  48. /* #define DEBUG 1        /* */
  49. #ifdef DEBUG
  50. # define DENTER(NAME)    (printf("Entering %s\n",NAME), fflush(stdout)) 
  51. # define DEXIT(NAME)    (printf("Exiting  %s\n",NAME), fflush(stdout))
  52. #else
  53. # define DENTER(NAME)    
  54. # define DEXIT(NAME)    
  55. #endif 
  56.  
  57. #define DRAIN_INPUT()    (msg_recv_serial((union msg_t*)0))
  58.  
  59. extern int stop_soon_quietly;           /* for wait_for_inferior */
  60.  
  61. static void mm_resume();
  62. static void mm_fetch_registers ();
  63. static int fetch_register ();
  64. static int mm_store_registers ();
  65. static int store_register ();
  66. static int regnum_to_srnum();
  67. static void  mm_close ();
  68. static char* msg_str();
  69. static char* error_msg_str();
  70. static int expect_msg();
  71. static void init_target_mm();
  72. static int mm_memory_space();
  73.  
  74. /*
  75.  * Processor types. 
  76.  */
  77. #define TYPE_UNKNOWN    0
  78. #define TYPE_A29000     1
  79. #define TYPE_A29030     2
  80. #define TYPE_A29050     3
  81. static  char *processor_name[] = { "Unknown", "A29000", "A29030", "A29050" };
  82. static  int processor_type=TYPE_UNKNOWN;
  83. #define FREEZE_MODE     (read_register(CPS_REGNUM) && 0x400)
  84. #define USE_SHADOW_PC    ((processor_type == TYPE_A29050) && FREEZE_MODE) 
  85.  
  86. #define LLOG_FILE "minimon.log"
  87. #if defined (LOG_FILE)
  88. FILE *log_file;
  89. #endif
  90.  
  91. /*  
  92.  * Size of message buffers.  I couldn't get memory reads to work when
  93.  * the byte_count was larger than 512 (it may be a baud rate problem).
  94.  */
  95. #define BUFER_SIZE  512        
  96. /* 
  97.  * Size of data area in message buffer on the TARGET (remote system).
  98.  */
  99. #define MAXDATA_T  (target_config.max_msg_size - \
  100.             offsetof(struct write_r_msg_t,data[0]))
  101. /*         
  102.  * Size of data area in message buffer on the HOST (gdb). 
  103.  */
  104. #define MAXDATA_H  (BUFER_SIZE - offsetof(struct write_r_msg_t,data[0]))
  105. /* 
  106.  * Defined as the minimum size of data areas of the two message buffers 
  107.  */
  108. #define MAXDATA       (MAXDATA_H < MAXDATA_T ? MAXDATA_H : MAXDATA_T)
  109.  
  110. static char out_buf[BUFER_SIZE];
  111. static char  in_buf[BUFER_SIZE];
  112.  
  113. int msg_recv_serial();
  114. int msg_send_serial();
  115.  
  116. #define MAX_RETRIES 5000
  117. extern struct target_ops mm_ops;             /* Forward declaration */
  118. struct config_msg_t  target_config;    /* HIF needs this */
  119. union msg_t  *out_msg_buf = (union msg_t*)out_buf;
  120. union msg_t  *in_msg_buf  = (union msg_t*)in_buf;
  121.  
  122. static int timeout = 5;
  123.  
  124. /* Descriptor for I/O to remote machine.  Initialize it to -1 so that
  125.    mm_open knows that we don't have a file open when the program
  126.    starts.  */
  127. int mm_desc = -1;
  128.  
  129. /* stream which is fdopen'd from mm_desc.  Only valid when
  130.    mm_desc != -1.  */
  131. FILE *mm_stream;
  132.  
  133. /* Called when SIGALRM signal sent due to alarm() timeout.  */
  134. #ifndef HAVE_TERMIO
  135.  
  136. #ifndef __STDC__
  137. # ifndef volatile
  138. #  define volatile /**/
  139. # endif
  140. #endif
  141. volatile int n_alarms;
  142.  
  143. static void
  144. mm_timer ()
  145. {
  146. #if 0
  147.   if (kiodebug)
  148.     printf ("mm_timer called\n");
  149. #endif
  150.   n_alarms++;
  151. }
  152. #endif    /* HAVE_TERMIO */
  153.  
  154. /* malloc'd name of the program on the remote system.  */
  155. static char *prog_name = NULL;
  156.  
  157.  
  158. /* Number of SIGTRAPs we need to simulate.  That is, the next
  159.    NEED_ARTIFICIAL_TRAP calls to mm_wait should just return
  160.    SIGTRAP without actually waiting for anything.  */
  161.  
  162. /**************************************************** REMOTE_CREATE_INFERIOR */
  163. /* This is called not only when we first attach, but also when the
  164.    user types "run" after having attached.  */
  165. static void
  166. mm_create_inferior (execfile, args, env)
  167.      char *execfile;
  168.      char *args;
  169.      char **env;
  170. {
  171. #define MAX_TOKENS 25
  172. #define BUFFER_SIZE 256
  173.    int    token_count;
  174.    int    result;
  175.    char    *token[MAX_TOKENS];
  176.    char    cmd_line[BUFFER_SIZE];
  177.  
  178.   DENTER("mm_create_inferior()");
  179.  
  180.   if (args && *args)
  181.     error ("Can't pass arguments to remote mm process (yet).");
  182.  
  183.   if (execfile == 0 /* || exec_bfd == 0 */ )
  184.     error ("No exec file specified");
  185.  
  186.   if (!mm_stream) {
  187.         printf("Minimon not open yet.\n");
  188.     return;
  189.   }
  190.  
  191.   /* On ultra3 (NYU) we assume the kernel is already running so there is
  192.      no file to download.
  193.      FIXME: Fixed required here -> load your program, possibly with mm_load().
  194.      */
  195.   printf_filtered ("\n\
  196. Assuming you are at NYU debuging a kernel, i.e., no need to download.\n\n");
  197.  
  198.   /* We will get a task spawn event immediately.  */
  199. #ifdef NOTDEF        /* start_remote() now does a wait without a resume 
  200.                so don't use it*/ 
  201.   start_remote ();
  202. #else
  203.   init_wait_for_inferior ();
  204.   clear_proceed_status ();
  205.   stop_soon_quietly = 1;
  206.   proceed(-1,-1,0);
  207.   normal_stop ();
  208. #endif
  209.   DEXIT("mm_create_inferior()");
  210. }
  211. /**************************************************** REMOTE_MOURN_INFERIOR */
  212. static void
  213. mm_mourn()
  214. {
  215.   DENTER("mm_mourn()");
  216.         pop_target ();                /* Pop back to no-child state */
  217.         generic_mourn_inferior ();
  218.   DEXIT("mm_mourn()");
  219. }
  220.  
  221. /********************************************************************** damn_b
  222. */
  223. /* Translate baud rates from integers to damn B_codes.  Unix should
  224.    have outgrown this crap years ago, but even POSIX wouldn't buck it.  */
  225.  
  226. #ifndef B19200
  227. #define B19200 EXTA
  228. #endif
  229. #ifndef B38400
  230. #define B38400 EXTB
  231. #endif
  232.  
  233. static struct {int rate, damn_b;} baudtab[] = {
  234.     {0, B0},
  235.     {50, B50},
  236.     {75, B75},
  237.     {110, B110},
  238.     {134, B134},
  239.     {150, B150},
  240.     {200, B200},
  241.     {300, B300},
  242.     {600, B600},
  243.     {1200, B1200},
  244.     {1800, B1800},
  245.     {2400, B2400},
  246.     {4800, B4800},
  247.     {9600, B9600},
  248.     {19200, B19200},
  249.     {38400, B38400},
  250.     {-1, -1},
  251. };
  252.  
  253. static int damn_b (rate)
  254.      int rate;
  255. {
  256.   int i;
  257.  
  258.   for (i = 0; baudtab[i].rate != -1; i++)
  259.     if (rate == baudtab[i].rate) return baudtab[i].damn_b;
  260.   return B38400;    /* Random */
  261. }
  262.  
  263.  
  264. /***************************************************************** REMOTE_OPEN
  265. ** Open a connection to remote minimon.
  266.    NAME is the filename used for communication, then a space,
  267.    then the baud rate.
  268.    'target adapt /dev/ttya 9600 [prognam]' for example.
  269.  */
  270.  
  271. static char *dev_name;
  272. int baudrate = 9600;
  273. static void
  274. mm_open (name, from_tty)
  275.      char *name;
  276.      int from_tty;
  277. {
  278.   TERMINAL sg;
  279.   unsigned int prl;
  280.   char *p;
  281.  
  282.   DENTER("mm_open()");
  283.  
  284.   /* Find the first whitespace character, it separates dev_name from
  285.      prog_name.  */
  286.   for (p = name;
  287.        p && *p && !isspace (*p); p++)
  288.     ;
  289.   if (p == 0 || *p == '\0')
  290. erroid:
  291.     error ("Usage : <command> <serial-device> <baud-rate> [progname]");
  292.   dev_name = (char*)malloc (p - name + 1);
  293.   strncpy (dev_name, name, p - name);
  294.   dev_name[p - name] = '\0';
  295.  
  296.   /* Skip over the whitespace after dev_name */
  297.   for (; isspace (*p); p++)
  298.     /*EMPTY*/;
  299.   
  300.   if (1 != sscanf (p, "%d ", &baudrate))
  301.     goto erroid;
  302.  
  303.   /* Skip the number and then the spaces */
  304.   for (; isdigit (*p); p++)
  305.     /*EMPTY*/;
  306.   for (; isspace (*p); p++)
  307.     /*EMPTY*/;
  308.   
  309.   if (prog_name != NULL)
  310.     free (prog_name);
  311.   prog_name = savestring (p, strlen (p));
  312.  
  313.  
  314.   if (mm_desc >= 0)
  315.     close (mm_desc);
  316.  
  317.   mm_desc = open (dev_name, O_RDWR);
  318.   if (mm_desc < 0)
  319.     perror_with_name (dev_name);
  320.   ioctl (mm_desc, TIOCGETP, &sg);
  321. #ifdef HAVE_TERMIO
  322.   sg.c_cc[VMIN] = 0;        /* read with timeout.  */
  323.   sg.c_cc[VTIME] = timeout * 10;
  324.   sg.c_lflag &= ~(ICANON | ECHO);
  325.   sg.c_cflag = (sg.c_cflag & ~CBAUD) | damn_b (baudrate);
  326. #else
  327.   sg.sg_ispeed = damn_b (baudrate);
  328.   sg.sg_ospeed = damn_b (baudrate);
  329.   sg.sg_flags |= RAW;
  330.   sg.sg_flags |= ANYP;
  331.   sg.sg_flags &= ~ECHO;
  332. #endif
  333.  
  334.  
  335.   ioctl (mm_desc, TIOCSETP, &sg);
  336.   mm_stream = fdopen (mm_desc, "r+");
  337.  
  338.   push_target (&mm_ops);
  339.  
  340. #ifndef HAVE_TERMIO
  341. #ifndef NO_SIGINTERRUPT
  342.   /* Cause SIGALRM's to make reads fail with EINTR instead of resuming
  343.      the read.  */
  344.   if (siginterrupt (SIGALRM, 1) != 0)
  345.     perror ("mm_open: error in siginterrupt");
  346. #endif
  347.  
  348.   /* Set up read timeout timer.  */
  349.   if ((void (*)) signal (SIGALRM, mm_timer) == (void (*)) -1)
  350.     perror ("mm_open: error in signal");
  351. #endif
  352.  
  353. #if defined (LOG_FILE)
  354.   log_file = fopen (LOG_FILE, "w");
  355.   if (log_file == NULL)
  356.     perror_with_name (LOG_FILE);
  357. #endif
  358.    /*
  359.    ** Initialize target configuration structure (global)
  360.    */
  361.    DRAIN_INPUT();
  362.    out_msg_buf->config_req_msg.code = CONFIG_REQ;
  363.    out_msg_buf->config_req_msg.length = 4*0;
  364.    msg_send_serial(out_msg_buf); /* send config request message */
  365.  
  366.    expect_msg(CONFIG,in_msg_buf,1);
  367.  
  368.   /* Determine the processor revision level */
  369.   /* FIXME: this code is the same as in remote-adapt.c */
  370.   prl = (unsigned int)read_register(CFG_REGNUM) >> 24;
  371.   if (prl == 0x03) {
  372.         processor_type = TYPE_A29000;
  373.   } else if ((prl&0xf0) == 0x40) {      /* 29030 = 0x4* */
  374.         processor_type = TYPE_A29030;
  375.         fprintf_filtered(stderr,"WARNING: debugging of A29030 not tested.\n");
  376.   } else if ((prl&0xf0) == 0x20) {      /* 29050 = 0x2* */
  377.         processor_type = TYPE_A29050;
  378.         fprintf_filtered(stderr,"WARNING: debugging of A29050 not tested.\n");
  379.   } else {
  380.         processor_type = TYPE_UNKNOWN;
  381.         fprintf_filtered(stderr,"WARNING: processor type unknown.\n");
  382.   }
  383.  
  384.   /* Print out some stuff, letting the user now what's going on */
  385.   printf_filtered("Remote debugging on an %s connect to MiniMon via %s.\n",
  386.                 processor_name[processor_type],dev_name);
  387.     /* FIXME: can this restriction be removed? */
  388.   printf_filtered("Remote debugging using virtual addresses works only\n");
  389.   printf_filtered("\twhen virtual addresses map 1:1 to physical addresses.\n")
  390. ;
  391.   if (processor_type != TYPE_A29050) {
  392.         fprintf_filtered(stderr,
  393.         "Freeze-mode debugging not available, and can only be done on an A29050.\n");
  394.   }
  395.  
  396.    target_config.code = CONFIG;
  397.    target_config.length = 0;
  398.    target_config.processor_id = in_msg_buf->config_msg.processor_id;
  399.    target_config.version = in_msg_buf->config_msg.version;
  400.    target_config.I_mem_start = in_msg_buf->config_msg.I_mem_start;
  401.    target_config.I_mem_size = in_msg_buf->config_msg.I_mem_size;
  402.    target_config.D_mem_start = in_msg_buf->config_msg.D_mem_start;
  403.    target_config.D_mem_size = in_msg_buf->config_msg.D_mem_size;
  404.    target_config.ROM_start = in_msg_buf->config_msg.ROM_start;
  405.    target_config.ROM_size =  in_msg_buf->config_msg.ROM_size;
  406.    target_config.max_msg_size = in_msg_buf->config_msg.max_msg_size;
  407.    target_config.max_bkpts = in_msg_buf->config_msg.max_bkpts;
  408.    target_config.coprocessor = in_msg_buf->config_msg.coprocessor;
  409.    target_config.reserved = in_msg_buf->config_msg.reserved;
  410.    if (from_tty) {
  411.        printf("Connected to MiniMON :\n");
  412.     printf("    Debugcore version            %d.%d\n",
  413.         0x0f & (target_config.version >> 4),
  414.         0x0f & (target_config.version ) );
  415.     printf("    Configuration version        %d.%d\n",
  416.         0x0f & (target_config.version >> 12),
  417.         0x0f & (target_config.version >>  8) );
  418.     printf("    Message system version       %d.%d\n",
  419.         0x0f & (target_config.version >> 20),
  420.         0x0f & (target_config.version >> 16) );
  421.     printf("    Communication driver version %d.%d\n",
  422.         0x0f & (target_config.version >> 28),
  423.         0x0f & (target_config.version >> 24) );
  424.    }
  425.  
  426.   /* Leave the target running... 
  427.    * The above message stopped the target in the dbg core (MiniMon),  
  428.    * so restart the target out of MiniMon, 
  429.    */
  430.   out_msg_buf->go_msg.code = GO;
  431.   out_msg_buf->go_msg.length = 0;
  432.   msg_send_serial(out_msg_buf);
  433.   /* No message to expect after a GO */
  434.  
  435.   DEXIT("mm_open()");
  436. }
  437.  
  438. /**************************************************************** REMOTE_CLOSE
  439. ** Close the open connection to the minimon debugger.
  440.    Use this when you want to detach and do something else
  441.    with your gdb.  */
  442. static void
  443. mm_close (quitting)    /*FIXME: how is quitting used */
  444.      int quitting;
  445. {
  446.   DENTER("mm_close()");
  447.  
  448.   if (mm_desc < 0)
  449.     error ("Can't close remote connection: not debugging remotely.");
  450.  
  451.   /* We should never get here if there isn't something valid in
  452.      mm_desc and mm_stream.  
  453.  
  454.      Due to a bug in Unix, fclose closes not only the stdio stream,
  455.      but also the file descriptor.  So we don't actually close
  456.      mm_desc.  */
  457.   DRAIN_INPUT();
  458.   fclose (mm_stream);    
  459.   /* close (mm_desc); */
  460.  
  461.   /* Do not try to close mm_desc again, later in the program.  */
  462.   mm_stream = NULL;
  463.   mm_desc = -1;
  464.  
  465. #if defined (LOG_FILE)
  466.   if (ferror (log_file))
  467.     printf ("Error writing log file.\n");
  468.   if (fclose (log_file) != 0)
  469.     printf ("Error closing log file.\n");
  470. #endif
  471.  
  472.   printf ("Ending remote debugging\n");
  473.  
  474.   DEXIT("mm_close()");
  475.  
  476. } 
  477.  
  478. /************************************************************* REMOTE_ATACH */
  479. /* Attach to a program that is already loaded and running 
  480.  * Upon exiting the process's execution is stopped.
  481.  */
  482. static void
  483. mm_attach (args, from_tty)
  484.      char *args;
  485.      int from_tty;
  486. {
  487.  
  488.   DENTER("mm_attach()");
  489.  
  490.   if (!mm_stream)
  491.       printf ("MiniMon not opened yet, use the 'target minimon' command.\n");
  492.     
  493.   dont_repeat();
  494.  
  495.   if (from_tty)
  496.       printf ("Attaching to remote program %s...\n", prog_name);
  497.  
  498.  
  499.   /* Make sure the target is currently running, it is supposed to be. */
  500.   /* FIXME: is it ok to send MiniMon a BREAK if it is already stopped in 
  501.    *     the dbg core.  If so, we don't need to send this GO.
  502.    */
  503.   out_msg_buf->go_msg.code = GO;
  504.   out_msg_buf->go_msg.length = 0;
  505.   msg_send_serial(out_msg_buf);
  506.   sleep(2);    /* At the worst it will stop, receive a message, continue */
  507.  
  508.   /* Send the mm a break. */ 
  509.   out_msg_buf->break_msg.code = BREAK;
  510.   out_msg_buf->break_msg.length = 0;
  511.   msg_send_serial(out_msg_buf);
  512.  
  513.   mark_breakpoints_out ();
  514.   init_wait_for_inferior ();
  515.   clear_proceed_status ();
  516.   stop_soon_quietly = 1;
  517.   wait_for_inferior ();
  518.   stop_soon_quietly = 0;
  519.   normal_stop ();
  520.  
  521.   DEXIT("mm_attach()");
  522. }
  523. /********************************************************** REMOTE_DETACH */
  524. /* Terminate the open connection to the remote debugger.
  525.    Use this when you want to detach and do something else
  526.    with your gdb.  Leave remote process running (with no breakpoints set). */
  527. static void
  528. mm_detach (args,from_tty)
  529.      char *args;
  530.      int from_tty;
  531. {
  532.   DENTER("mm_dettach()");
  533.   remove_breakpoints();        /* Just in case there were any left in */
  534.   out_msg_buf->go_msg.code = GO;
  535.   out_msg_buf->go_msg.length = 0;
  536.   msg_send_serial(out_msg_buf);
  537.   pop_target();             /* calls mm_close to do the real work */
  538.   DEXIT("mm_dettach()");
  539. }
  540.  
  541.  
  542. /*************************************************************** REMOTE_RESUME
  543. ** Tell the remote machine to resume.  */
  544.  
  545. static void
  546. mm_resume (step, sig)
  547.      int step, sig;
  548. {
  549.   DENTER("mm_resume()");
  550.  
  551.   if (sig)
  552.     error ("Can't send signals to a remote MiniMon system.");
  553.  
  554.   if (step) {
  555.       out_msg_buf->step_msg.code= STEP;
  556.       out_msg_buf->step_msg.length = 1*4;
  557.       out_msg_buf->step_msg.count = 1;        /* step 1 instruction */
  558.       msg_send_serial(out_msg_buf);
  559.   } else {
  560.       out_msg_buf->go_msg.code= GO;
  561.       out_msg_buf->go_msg.length = 0;
  562.       msg_send_serial(out_msg_buf);
  563.   }
  564.  
  565.   DEXIT("mm_resume()");
  566. }
  567.  
  568. /***************************************************************** REMOTE_WAIT
  569. ** Wait until the remote machine stops, then return,
  570.    storing status in STATUS just as `wait' would.  */
  571.  
  572. static int
  573. mm_wait (status)
  574.      WAITTYPE *status;
  575. {
  576.   int i, result;
  577.   int old_timeout = timeout;
  578.   int old_immediate_quit = immediate_quit;
  579.  
  580.   DENTER("mm_wait()");
  581.   WSETEXIT ((*status), 0);
  582.  
  583.  
  584. /* wait for message to arrive. It should be:
  585.     - A HIF service request.
  586.     - A HIF exit service request.
  587.     - A CHANNEL0_ACK.
  588.     - A CHANNEL1 request.
  589.     - a debugcore HALT message.
  590.   HIF services must be responded too, and while-looping continued.
  591.   If the target stops executing, mm_wait() should return.
  592. */
  593.   timeout = 0;    /* Wait indefinetly for a message */
  594.   immediate_quit = 1;   /* Helps ability to QUIT */
  595.   while(1)
  596.   {
  597.     while(msg_recv_serial(in_msg_buf)) {
  598.         QUIT;    /* Let user quit if they want */
  599.     }
  600.     switch (in_msg_buf->halt_msg.code)
  601.     {
  602.     case HIF_CALL:
  603.     i = in_msg_buf->hif_call_rtn_msg.service_number;
  604.     result=service_HIF(in_msg_buf);
  605.        if(i == 1) /* EXIT */
  606.         goto exit;
  607.     if(result)
  608.         printf("Warning: failure during HIF service %d\n", i);
  609.     break;
  610.     case CHANNEL0_ACK:
  611.     service_HIF(in_msg_buf);
  612.     break;
  613.     case CHANNEL1:
  614.         i=in_msg_buf->channel1_msg.length;
  615.         in_msg_buf->channel1_msg.data[i] = '\0';
  616.         printf("%s", in_msg_buf->channel1_msg.data);
  617.     fflush(stdout);
  618.         /* Send CHANNEL1_ACK message */
  619.         out_msg_buf->channel1_ack_msg.code = CHANNEL1_ACK;
  620.         out_msg_buf->channel1_ack_msg.length = 0;
  621.         result = msg_send_serial(out_msg_buf);
  622.     break;
  623.     case HALT:
  624.     goto halted;
  625.     default:
  626.     goto halted;
  627.     }
  628.   }
  629. halted:
  630.   /* FIXME, these printfs should not be here.  This is a source level 
  631.      debugger, guys!  */
  632.   if (in_msg_buf->halt_msg.trap_number== 0)
  633.   { printf("Am290*0 received vector number %d (break point)\n",
  634.     in_msg_buf->halt_msg.trap_number);
  635.     WSETSTOP ((*status), SIGTRAP);
  636.   }
  637.   else if (in_msg_buf->halt_msg.trap_number== 1)
  638.   { printf("Am290*0 received vector number %d\n",
  639.     in_msg_buf->halt_msg.trap_number);
  640.     WSETSTOP ((*status), SIGBUS);
  641.   }
  642.   else if (in_msg_buf->halt_msg.trap_number== 3
  643.         || in_msg_buf->halt_msg.trap_number== 4)
  644.   { printf("Am290*0 received vector number %d\n",
  645.     in_msg_buf->halt_msg.trap_number);
  646.     WSETSTOP ((*status), SIGFPE);
  647.   }
  648.   else if (in_msg_buf->halt_msg.trap_number== 5)
  649.   { printf("Am290*0 received vector number %d\n",
  650.     in_msg_buf->halt_msg.trap_number);
  651.     WSETSTOP ((*status), SIGILL);
  652.   }
  653.   else if (in_msg_buf->halt_msg.trap_number >= 6
  654.         && in_msg_buf->halt_msg.trap_number <= 11)
  655.   { printf("Am290*0 received vector number %d\n",
  656.     in_msg_buf->halt_msg.trap_number);
  657.     WSETSTOP ((*status), SIGSEGV);
  658.   }
  659.   else if (in_msg_buf->halt_msg.trap_number== 12
  660.         || in_msg_buf->halt_msg.trap_number== 13)
  661.   { printf("Am290*0 received vector number %d\n",
  662.     in_msg_buf->halt_msg.trap_number);
  663.     WSETSTOP ((*status), SIGILL);
  664.   }
  665.   else if (in_msg_buf->halt_msg.trap_number== 14)
  666.   { printf("Am290*0 received vector number %d\n",
  667.     in_msg_buf->halt_msg.trap_number);
  668.     WSETSTOP ((*status), SIGALRM);
  669.   }
  670.   else if (in_msg_buf->halt_msg.trap_number== 15)
  671.     WSETSTOP ((*status), SIGTRAP);
  672.   else if (in_msg_buf->halt_msg.trap_number >= 16
  673.         && in_msg_buf->halt_msg.trap_number <= 21)
  674.   { printf("Am290*0 received vector number %d\n",
  675.     in_msg_buf->halt_msg.trap_number);
  676.     WSETSTOP ((*status), SIGINT);
  677.   }
  678.   else if (in_msg_buf->halt_msg.trap_number== 22)
  679.   { printf("Am290*0 received vector number %d\n",
  680.     in_msg_buf->halt_msg.trap_number);
  681.     WSETSTOP ((*status), SIGILL);
  682.   } /* BREAK message was sent */
  683.   else if (in_msg_buf->halt_msg.trap_number== 75)
  684.     WSETSTOP ((*status), SIGTRAP);
  685.   else
  686. exit:
  687.     WSETEXIT ((*status), 0);
  688.  
  689.   timeout = old_timeout;    /* Restore original timeout value */
  690.   immediate_quit = old_immediate_quit;
  691.   DEXIT("mm_wait()");
  692.   return 0;
  693. }
  694.  
  695. /******************************************************* REMOTE_FETCH_REGISTERS
  696.  * Read a remote register 'regno'. 
  697.  * If regno==-1 then read all the registers.
  698.  */
  699. static void 
  700. mm_fetch_registers (regno)
  701. int    regno;
  702. {
  703.   INT32 *data_p;
  704.  
  705.   if (regno >= 0)  {
  706.     fetch_register(regno);
  707.     return;
  708.   }
  709.  
  710.   DENTER("mm_fetch_registers()");
  711.  
  712. /* Gr1/rsp */
  713.   out_msg_buf->read_req_msg.byte_count = 4*1;
  714.   out_msg_buf->read_req_msg.memory_space = GLOBAL_REG;
  715.   out_msg_buf->read_req_msg.address = 1;
  716.   msg_send_serial(out_msg_buf);
  717.   expect_msg(READ_ACK,in_msg_buf,1);
  718.   data_p = &(in_msg_buf->read_r_ack_msg.data[0]);
  719.   supply_register (GR1_REGNUM , data_p);
  720.  
  721. #if defined(GR64_REGNUM)    /* Read gr64-127 */
  722. /* Global Registers gr64-gr95 */ 
  723.   out_msg_buf->read_req_msg.code= READ_REQ;
  724.   out_msg_buf->read_req_msg.length = 4*3;
  725.   out_msg_buf->read_req_msg.byte_count = 4*32;
  726.   out_msg_buf->read_req_msg.memory_space = GLOBAL_REG;
  727.   out_msg_buf->read_req_msg.address = 64;
  728.   msg_send_serial(out_msg_buf);
  729.   expect_msg(READ_ACK,in_msg_buf,1);
  730.   data_p = &(in_msg_buf->read_r_ack_msg.data[0]);
  731.  
  732.   for (regno=GR64_REGNUM; regno<GR64_REGNUM+32; regno++) {
  733.       supply_register (regno, data_p++);
  734.   }
  735. #endif    /*  GR64_REGNUM */
  736.  
  737. /* Global Registers gr96-gr127 */ 
  738.   out_msg_buf->read_req_msg.code= READ_REQ;
  739.   out_msg_buf->read_req_msg.length = 4*3;
  740.   out_msg_buf->read_req_msg.byte_count = 4 * 32;
  741.   out_msg_buf->read_req_msg.memory_space = GLOBAL_REG;
  742.   out_msg_buf->read_req_msg.address = 96;
  743.   msg_send_serial(out_msg_buf);
  744.   expect_msg(READ_ACK,in_msg_buf,1);
  745.   data_p = &(in_msg_buf->read_r_ack_msg.data[0]);
  746.  
  747.   for (regno=GR96_REGNUM; regno<GR96_REGNUM+32; regno++) {
  748.       supply_register (regno, data_p++);
  749.   }
  750.  
  751. /* Local Registers */ 
  752.   out_msg_buf->read_req_msg.byte_count = 4 * (128);
  753.   out_msg_buf->read_req_msg.memory_space = LOCAL_REG;
  754.   out_msg_buf->read_req_msg.address = 0;
  755.   msg_send_serial(out_msg_buf);
  756.   expect_msg(READ_ACK,in_msg_buf,1);
  757.   data_p = &(in_msg_buf->read_r_ack_msg.data[0]);
  758.  
  759.   for (regno=LR0_REGNUM; regno<LR0_REGNUM+128; regno++) {
  760.       supply_register (regno, data_p++);
  761.   }
  762.  
  763. /* Protected Special Registers */ 
  764.   out_msg_buf->read_req_msg.byte_count = 4*15;
  765.   out_msg_buf->read_req_msg.memory_space = SPECIAL_REG;
  766.   out_msg_buf->read_req_msg.address = 0;
  767.   msg_send_serial( out_msg_buf);
  768.   expect_msg(READ_ACK,in_msg_buf,1);
  769.   data_p = &(in_msg_buf->read_r_ack_msg.data[0]);
  770.  
  771.   for (regno=0; regno<=14; regno++) {
  772.       supply_register (SR_REGNUM(regno), data_p++);
  773.   }
  774.   if (USE_SHADOW_PC) {    /* Let regno_to_srnum() handle the register number */
  775.     fetch_register(NPC_REGNUM);
  776.     fetch_register(PC_REGNUM);
  777.     fetch_register(PC2_REGNUM);
  778.   }
  779.  
  780. /* Unprotected Special Registers */ 
  781.   out_msg_buf->read_req_msg.byte_count = 4*8;
  782.   out_msg_buf->read_req_msg.memory_space = SPECIAL_REG;
  783.   out_msg_buf->read_req_msg.address = 128;
  784.   msg_send_serial( out_msg_buf);
  785.   expect_msg(READ_ACK,in_msg_buf,1);
  786.   data_p = &(in_msg_buf->read_r_ack_msg.data[0]);
  787.  
  788.   for (regno=128; regno<=135; regno++) {
  789.       supply_register (SR_REGNUM(regno), data_p++);
  790.   }
  791.  
  792.   /* There doesn't seem to be any way to get these.  */
  793.   {
  794.     int val = -1;
  795.     supply_register (FPE_REGNUM, &val);
  796.     supply_register (INT_REGNUM, &val);
  797.     supply_register (FPS_REGNUM, &val);
  798.     supply_register (EXO_REGNUM, &val);
  799.   }
  800.  
  801.   DEXIT("mm_fetch_registerS()");
  802. }
  803.  
  804.  
  805. /****************************************************** REMOTE_STORE_REGISTERS
  806.  * Store register regno into the target.  
  807.  * If regno==-1 then store all the registers.
  808.  * Result is 0 for success, -1 for failure.
  809.  */
  810.  
  811. static int 
  812. mm_store_registers (regno)
  813. int regno;
  814. {
  815.   int result;
  816.   
  817.   if (regno >= 0)
  818.     return(store_register(regno));
  819.  
  820.   DENTER("mm_store_registers()");
  821.   result = 0;
  822.  
  823.   out_msg_buf->write_r_msg.code= WRITE_REQ;
  824.  
  825. /* Gr1/rsp */
  826.   out_msg_buf->write_r_msg.byte_count = 4*1;
  827.   out_msg_buf->write_r_msg.length = 3*4 + out_msg_buf->write_r_msg.byte_count;
  828.   out_msg_buf->write_r_msg.memory_space = GLOBAL_REG;
  829.   out_msg_buf->write_r_msg.address = 1;
  830.   out_msg_buf->write_r_msg.data[0] = read_register (GR1_REGNUM);
  831.  
  832.   msg_send_serial( out_msg_buf);
  833.   if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
  834.     result = -1;
  835.   }
  836.  
  837. #if defined(GR64_REGNUM)
  838. /* Global registers gr64-gr95 */
  839.   out_msg_buf->write_r_msg.byte_count = 4* (32);
  840.   out_msg_buf->write_r_msg.length = 3*4 + out_msg_buf->write_r_msg.byte_count;
  841.   out_msg_buf->write_r_msg.address = 64;
  842.  
  843.   for (regno=GR64_REGNUM ; regno<GR64_REGNUM+32 ; regno++)
  844.     {
  845.       out_msg_buf->write_r_msg.data[regno-GR64_REGNUM] = read_register (regno);
  846.     }
  847.   msg_send_serial(out_msg_buf);
  848.   if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
  849.     result = -1;
  850.   }
  851. #endif    /* GR64_REGNUM */
  852.  
  853. /* Global registers gr96-gr127 */
  854.   out_msg_buf->write_r_msg.byte_count = 4* (32);
  855.   out_msg_buf->write_r_msg.length = 3*4 + out_msg_buf->write_r_msg.byte_count;
  856.   out_msg_buf->write_r_msg.address = 96;
  857.   for (regno=GR96_REGNUM ; regno<GR96_REGNUM+32 ; regno++)
  858.     {
  859.       out_msg_buf->write_r_msg.data[regno-GR96_REGNUM] = read_register (regno);
  860.     }
  861.   msg_send_serial( out_msg_buf);
  862.   if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
  863.     result = -1;
  864.   }
  865.  
  866. /* Local Registers */
  867.   out_msg_buf->write_r_msg.memory_space = LOCAL_REG;
  868.   out_msg_buf->write_r_msg.byte_count = 4*128;
  869.   out_msg_buf->write_r_msg.length = 3*4 + out_msg_buf->write_r_msg.byte_count;
  870.   out_msg_buf->write_r_msg.address = 0;
  871.  
  872.   for (regno = LR0_REGNUM ; regno < LR0_REGNUM+128 ; regno++)
  873.     {
  874.       out_msg_buf->write_r_msg.data[regno-LR0_REGNUM] = read_register (regno);
  875.     }
  876.   msg_send_serial( out_msg_buf);
  877.   if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
  878.     result = -1;
  879.   }
  880.  
  881. /* Protected Special Registers */ 
  882.   /* VAB through TMR */
  883.   out_msg_buf->write_r_msg.memory_space = SPECIAL_REG;
  884.   out_msg_buf->write_r_msg.byte_count = 4* 10;
  885.   out_msg_buf->write_r_msg.length = 3*4 + out_msg_buf->write_r_msg.byte_count;
  886.   out_msg_buf->write_r_msg.address = 0;
  887.   for (regno = 0 ; regno<=9 ; regno++)    /* VAB through TMR */
  888.     out_msg_buf->write_r_msg.data[regno] = read_register (SR_REGNUM(regno));
  889.   msg_send_serial( out_msg_buf);
  890.   if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
  891.     result = -1;
  892.   }
  893.  
  894.   /* PC0, PC1, PC2 possibly as shadow registers */
  895.   out_msg_buf->write_r_msg.byte_count = 4* 3;
  896.   out_msg_buf->write_r_msg.length = 3*4 + out_msg_buf->write_r_msg.byte_count;
  897.   for (regno=10 ; regno<=12 ; regno++)    /* LRU and MMU */
  898.     out_msg_buf->write_r_msg.data[regno-10] = read_register (SR_REGNUM(regno));
  899.   if (USE_SHADOW_PC) 
  900.     out_msg_buf->write_r_msg.address = 20;    /* SPC0 */
  901.   else 
  902.     out_msg_buf->write_r_msg.address = 10;    /* PC0 */
  903.   msg_send_serial( out_msg_buf);
  904.   if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
  905.     result = -1;
  906.   }
  907.  
  908.   /* LRU and MMU */
  909.   out_msg_buf->write_r_msg.byte_count = 4* 2;
  910.   out_msg_buf->write_r_msg.length = 3*4 + out_msg_buf->write_r_msg.byte_count;
  911.   out_msg_buf->write_r_msg.address = 13;
  912.   for (regno=13 ; regno<=14 ; regno++)    /* LRU and MMU */
  913.     out_msg_buf->write_r_msg.data[regno-13] = read_register (SR_REGNUM(regno));
  914.   msg_send_serial( out_msg_buf);
  915.   if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
  916.     result = -1;
  917.   }
  918.  
  919. /* Unprotected Special Registers */ 
  920.   out_msg_buf->write_r_msg.byte_count = 4*8;
  921.   out_msg_buf->write_r_msg.length = 3*4 + out_msg_buf->write_r_msg.byte_count;
  922.   out_msg_buf->write_r_msg.address = 128;
  923.   for (regno = 128 ; regno<=135 ; regno++)
  924.     out_msg_buf->write_r_msg.data[regno-128] = read_register(SR_REGNUM(regno));
  925.   msg_send_serial( out_msg_buf);
  926.   if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
  927.     result = -1;
  928.   }
  929.  
  930.   registers_changed ();
  931.   DEXIT("mm_store_registers()");
  932.   return result;
  933. }
  934.  
  935. /*************************************************** REMOTE_PREPARE_TO_STORE */
  936. /* Get ready to modify the registers array.  On machines which store
  937.    individual registers, this doesn't need to do anything.  On machines
  938.    which store all the registers in one fell swoop, this makes sure
  939.    that registers contains all the registers from the program being
  940.    debugged.  */
  941.  
  942. static void
  943. mm_prepare_to_store ()
  944. {
  945.   /* Do nothing, since we can store individual regs */
  946. }
  947.  
  948. /******************************************************* REMOTE_XFER_MEMORY */
  949. static CORE_ADDR
  950. translate_addr(addr)
  951. CORE_ADDR addr;
  952. {
  953. #if defined(KERNEL_DEBUGGING)
  954.         /* Check for a virtual address in the kernel */
  955.         /* Assume physical address of ublock is in  paddr_u register */
  956.     /* FIXME: doesn't work for user virtual addresses */
  957.         if (addr >= UVADDR) {
  958.                 /* PADDR_U register holds the physical address of the ublock */
  959.                 CORE_ADDR i = (CORE_ADDR)read_register(PADDR_U_REGNUM);
  960.                 return(i + addr - (CORE_ADDR)UVADDR);
  961.         } else {
  962.             return(addr);
  963.         }
  964. #else
  965.         return(addr);
  966. #endif
  967. }
  968.  
  969. /******************************************************* REMOTE_FILES_INFO */
  970. static void
  971. mm_files_info ()
  972. {
  973.   printf ("\tAttached to %s at %d baud and running program %s.\n",
  974.           dev_name, baudrate, prog_name);
  975. }
  976.  
  977. /************************************************* REMOTE_INSERT_BREAKPOINT */
  978. static int
  979. mm_insert_breakpoint (addr, contents_cache)
  980.      CORE_ADDR addr;
  981.      char *contents_cache;
  982. {
  983.   DENTER("mm_insert_breakpoint()");
  984.   out_msg_buf->bkpt_set_msg.code = BKPT_SET;
  985.   out_msg_buf->bkpt_set_msg.length = 4*4;
  986.   out_msg_buf->bkpt_set_msg.memory_space = I_MEM;
  987.   out_msg_buf->bkpt_set_msg.bkpt_addr = (ADDR32) addr;
  988.   out_msg_buf->bkpt_set_msg.pass_count = 1;
  989.   out_msg_buf->bkpt_set_msg.bkpt_type = -1;    /* use illop for 29000 */
  990.   msg_send_serial( out_msg_buf);
  991.   if (expect_msg(BKPT_SET_ACK,in_msg_buf,1)) {
  992.       DEXIT("mm_insert_breakpoint() success");
  993.     return 0;        /* Success */
  994.   } else {
  995.       DEXIT("mm_insert_breakpoint() failure");
  996.     return 1;        /* Failure */
  997.   }
  998. }
  999.  
  1000. /************************************************* REMOTE_DELETE_BREAKPOINT */
  1001. static int
  1002. mm_remove_breakpoint (addr, contents_cache)
  1003.      CORE_ADDR addr;
  1004.      char *contents_cache;
  1005. {
  1006.   DENTER("mm_remove_breakpoint()");
  1007.   out_msg_buf->bkpt_rm_msg.code = BKPT_RM;
  1008.   out_msg_buf->bkpt_rm_msg.length = 4*3;
  1009.   out_msg_buf->bkpt_rm_msg.memory_space = I_MEM;
  1010.   out_msg_buf->bkpt_rm_msg.bkpt_addr = (ADDR32) addr;
  1011.   msg_send_serial( out_msg_buf);
  1012.   if (expect_msg(BKPT_RM_ACK,in_msg_buf,1)) {
  1013.       DEXIT("mm_remove_breakpoint()");
  1014.     return 0;        /* Success */
  1015.   } else {
  1016.       DEXIT("mm_remove_breakpoint()");
  1017.     return 1;        /* Failure */
  1018.   }
  1019. }
  1020.  
  1021.  
  1022. /******************************************************* REMOTE_KILL */
  1023. static void
  1024. mm_kill(arg,from_tty)
  1025. char    *arg;
  1026. int     from_tty;
  1027. {
  1028.     char    buf[4];
  1029.  
  1030.       DENTER("mm_kill()");
  1031. #if defined(KERNEL_DEBUGGING)
  1032.     /* We don't ever kill the kernel */
  1033.     if (from_tty) {
  1034.         printf("Kernel not killed, but left in current state.\n");
  1035.          printf("Use detach to leave kernel running.\n");
  1036.     }
  1037. #else
  1038.       out_msg_buf->break_msg.code = BREAK;
  1039.       out_msg_buf->bkpt_set_msg.length = 4*0;
  1040.     expect_msg(HALT,in_msg_buf,from_tty);
  1041.     if (from_tty) {
  1042.         printf("Target has been stopped.");
  1043.         printf("Would you like to do a hardware reset (y/n) [n] ");
  1044.         fgets(buf,3,stdin);    
  1045.         if (buf[0] == 'y') {
  1046.             out_msg_buf->reset_msg.code = RESET;
  1047.             out_msg_buf->bkpt_set_msg.length = 4*0;
  1048.             expect_msg(RESET_ACK,in_msg_buf,from_tty);
  1049.             printf("Target has been reset.");
  1050.         }
  1051.     }
  1052.     pop_target();
  1053. #endif 
  1054.     DEXIT("mm_kill()");
  1055. }
  1056.  
  1057.  
  1058.  
  1059. /***************************************************************************/
  1060. /* 
  1061.  * Load a program into the target.
  1062.  */
  1063. static void
  1064. mm_load(arg_string,from_tty)
  1065. char    *arg_string;
  1066. int    from_tty;
  1067. {
  1068.   dont_repeat ();
  1069.  
  1070. #if defined(KERNEL_DEBUGGING)
  1071.   printf("The kernel had better be loaded already!  Loading not done.\n");
  1072. #else
  1073.   if (arg_string == 0)
  1074.     error ("The load command takes a file name");
  1075.  
  1076.   arg_string = tilde_expand (arg_string);
  1077.   make_cleanup (free, arg_string);
  1078.   QUIT;
  1079.   immediate_quit++;
  1080.   error("File loading is not yet supported for MiniMon.");
  1081.   /* FIXME, code to load your file here... */
  1082.   /* You may need to do an init_target_mm() */
  1083.   /* init_target_mm(?,?,?,?,?,?,?,?); */
  1084.   immediate_quit--;
  1085.   /* (void) symbol_file_add (arg_string, from_tty, text_addr, 0, 0); */
  1086. #endif
  1087.  
  1088. }
  1089.  
  1090. /************************************************ REMOTE_WRITE_INFERIOR_MEMORY
  1091. ** Copy LEN bytes of data from debugger memory at MYADDR
  1092.    to inferior's memory at MEMADDR.  Returns number of bytes written.  */
  1093. static int
  1094. mm_write_inferior_memory (memaddr, myaddr, len)
  1095.      CORE_ADDR memaddr;
  1096.      char *myaddr;
  1097.      int len;
  1098. {
  1099.   int i,nwritten;
  1100.  
  1101.   /* DENTER("mm_write_inferior_memory()"); */
  1102.   out_msg_buf->write_req_msg.code= WRITE_REQ;
  1103.   out_msg_buf->write_req_msg.memory_space = mm_memory_space(memaddr);    
  1104.  
  1105.   nwritten=0;
  1106.   while (nwritten < len) {
  1107.     int num_to_write = len - nwritten;
  1108.     if (num_to_write > MAXDATA) num_to_write = MAXDATA;
  1109.       for (i=0 ; i < num_to_write ; i++)
  1110.               out_msg_buf->write_req_msg.data[i] = myaddr[i+nwritten];
  1111.       out_msg_buf->write_req_msg.byte_count = num_to_write;
  1112.       out_msg_buf->write_req_msg.length = 3*4 + num_to_write; 
  1113.       out_msg_buf->write_req_msg.address = memaddr + nwritten;
  1114.       msg_send_serial(out_msg_buf);
  1115.  
  1116.       if (expect_msg(WRITE_ACK,in_msg_buf,1)) {
  1117.           nwritten += in_msg_buf->write_ack_msg.byte_count;
  1118.       } else {
  1119.         break;    
  1120.       }
  1121.   }
  1122.   /* DEXIT("mm_write_inferior_memory()"); */
  1123.   return(nwritten);
  1124. }
  1125.  
  1126. /************************************************* REMOTE_READ_INFERIOR_MEMORY
  1127. ** Read LEN bytes from inferior memory at MEMADDR.  Put the result
  1128.    at debugger address MYADDR.  Returns number of bytes read.  */
  1129. static int
  1130. mm_read_inferior_memory(memaddr, myaddr, len)
  1131.      CORE_ADDR memaddr;
  1132.      char *myaddr;
  1133.      int len;
  1134. {
  1135.   int i,nread;
  1136.  
  1137.   /* DENTER("mm_read_inferior_memory()"); */
  1138.   out_msg_buf->read_req_msg.code= READ_REQ;
  1139.   out_msg_buf->read_req_msg.memory_space = mm_memory_space(memaddr);
  1140.  
  1141.   nread=0;
  1142.   while (nread < len) {
  1143.     int num_to_read = (len - nread);
  1144.     if (num_to_read > MAXDATA) num_to_read = MAXDATA;
  1145.       out_msg_buf->read_req_msg.byte_count = num_to_read; 
  1146.       out_msg_buf->read_req_msg.length = 3*4 + num_to_read; 
  1147.       out_msg_buf->read_req_msg.address = memaddr + nread;
  1148.       msg_send_serial(out_msg_buf);
  1149.  
  1150.       if (expect_msg(READ_ACK,in_msg_buf,1)) {
  1151.           for (i=0 ; i<in_msg_buf->read_ack_msg.byte_count ; i++)
  1152.                   myaddr[i+nread] = in_msg_buf->read_ack_msg.data[i];
  1153.           nread += in_msg_buf->read_ack_msg.byte_count;
  1154.       } else {
  1155.         break;    
  1156.       }
  1157.   }
  1158.   return(nread);
  1159. }
  1160.  
  1161. /* FIXME!  Merge these two.  */
  1162. static int
  1163. mm_xfer_inferior_memory (memaddr, myaddr, len, write)
  1164.      CORE_ADDR memaddr;
  1165.      char *myaddr;
  1166.      int len;
  1167.      int write;
  1168. {
  1169.  
  1170.   memaddr = translate_addr(memaddr);
  1171.  
  1172.   if (write)
  1173.     return mm_write_inferior_memory (memaddr, myaddr, len);
  1174.   else
  1175.     return mm_read_inferior_memory (memaddr, myaddr, len);
  1176. }
  1177.  
  1178.  
  1179. /********************************************************** MSG_SEND_SERIAL
  1180. ** This function is used to send a message over the
  1181. ** serial line.
  1182. **
  1183. ** If the message is successfully sent, a zero is
  1184. ** returned.  If the message was not sendable, a -1
  1185. ** is returned.  This function blocks.  That is, it
  1186. ** does not return until the message is completely
  1187. ** sent, or until an error is encountered.
  1188. **
  1189. */
  1190.  
  1191. int
  1192. msg_send_serial(msg_ptr)
  1193.    union  msg_t  *msg_ptr;
  1194. {
  1195.    INT32  message_size;
  1196.    int    byte_count;
  1197.    int    result;
  1198.    char   c;
  1199.  
  1200.    /* Send message header */
  1201.    byte_count = 0;
  1202.    message_size = msg_ptr->generic_msg.length + (2 * sizeof(INT32));
  1203.    do {
  1204.       c = *((char *)msg_ptr+byte_count);
  1205.       result = write(mm_desc, &c, 1);
  1206.       if (result == 1) {
  1207.          byte_count = byte_count + 1;
  1208.       }
  1209.    } while ((byte_count < message_size) );
  1210.  
  1211.    return(0);
  1212. }  /* end msg_send_serial() */
  1213.  
  1214. /********************************************************** MSG_RECV_SERIAL
  1215. ** This function is used to receive a message over a
  1216. ** serial line.
  1217. **
  1218. ** If the message is waiting in the buffer, a zero is
  1219. ** returned and the buffer pointed to by msg_ptr is filled
  1220. ** in.  If no message was available, a -1 is returned.
  1221. ** If timeout==0, wait indefinetly for a character.
  1222. **
  1223. */
  1224.  
  1225. int
  1226. msg_recv_serial(msg_ptr)
  1227. union  msg_t  *msg_ptr;
  1228. {
  1229.    static INT32  length=0;
  1230.    static INT32  byte_count=0;
  1231.    int    result;
  1232.    char   c;
  1233.   if(msg_ptr == 0)        /* re-sync request */
  1234.   {  length=0;
  1235.      byte_count=0;
  1236. #ifdef HAVE_TERMIO
  1237.      /* The timeout here is the prevailing timeout set with VTIME */
  1238.      ->"timeout==0 semantics not supported"
  1239.      read(mm_desc, in_buf, BUFER_SIZE);
  1240. #else
  1241.      alarm (1);
  1242.      read(mm_desc, in_buf, BUFER_SIZE);
  1243.      alarm (0);
  1244. #endif
  1245.      return(0);
  1246.   }
  1247.    /* Receive message */
  1248. #ifdef HAVE_TERMIO
  1249. /* Timeout==0, help support the mm_wait() routine */
  1250.    ->"timeout==0 semantics not supported (and its nice if they are)"
  1251.    result = read(mm_desc, &c, 1);
  1252. #else
  1253.   alarm(timeout);
  1254.   result = read(mm_desc, &c, 1);
  1255.   alarm (0);
  1256. #endif
  1257.   if ( result < 0) {
  1258.       if (errno == EINTR) {
  1259.           error ("Timeout reading from remote system.");
  1260.       } else
  1261.     perror_with_name ("remote");
  1262.   } else if (result == 1) {
  1263.       *((char *)msg_ptr+byte_count) = c;
  1264.       byte_count = byte_count + 1;
  1265.   }
  1266.  
  1267.    /* Message header received.  Save message length. */
  1268.   if (byte_count == (2 * sizeof(INT32)))
  1269.       length = msg_ptr->generic_msg.length;
  1270.  
  1271.   if (byte_count >= (length + (2 * sizeof(INT32)))) {
  1272.       /* Message received */
  1273.       byte_count = 0;
  1274.       return(0);
  1275.   } else
  1276.       return (-1);
  1277.  
  1278. }  /* end msg_recv_serial() */
  1279.  
  1280. /********************************************************************* KBD_RAW
  1281. ** This function is used to put the keyboard in "raw"
  1282. ** mode for BSD Unix.  The original status is saved
  1283. ** so that it may be restored later.
  1284. */
  1285. TERMINAL kbd_tbuf;
  1286.  
  1287. int
  1288. kbd_raw() {
  1289.    int    result;
  1290.    TERMINAL tbuf;
  1291.  
  1292.    /* Get keyboard termio (to save to restore original modes) */
  1293. #ifdef HAVE_TERMIO
  1294.    result = ioctl(0, TCGETA, &kbd_tbuf);
  1295. #else
  1296.    result = ioctl(0, TIOCGETP, &kbd_tbuf);
  1297. #endif
  1298.    if (result == -1)
  1299.       return (errno);
  1300.  
  1301.    /* Get keyboard TERMINAL (for modification) */
  1302. #ifdef HAVE_TERMIO
  1303.    result = ioctl(0, TCGETA, &tbuf);
  1304. #else
  1305.    result = ioctl(0, TIOCGETP, &tbuf);
  1306. #endif
  1307.    if (result == -1)
  1308.       return (errno);
  1309.  
  1310.    /* Set up new parameters */
  1311. #ifdef HAVE_TERMIO
  1312.    tbuf.c_iflag = tbuf.c_iflag &
  1313.       ~(INLCR | ICRNL | IUCLC | ISTRIP | IXON | BRKINT);
  1314.    tbuf.c_lflag = tbuf.c_lflag & ~(ICANON | ISIG | ECHO);
  1315.    tbuf.c_cc[4] = 0;  /* MIN */
  1316.    tbuf.c_cc[5] = 0;  /* TIME */
  1317. #else
  1318.    /* FIXME: not sure if this is correct (matches HAVE_TERMIO). */
  1319.    tbuf.sg_flags |= RAW;
  1320.    tbuf.sg_flags |= ANYP;
  1321.    tbuf.sg_flags &= ~ECHO;
  1322. #endif
  1323.  
  1324.    /* Set keyboard termio to new mode (RAW) */
  1325. #ifdef HAVE_TERMIO
  1326.    result = ioctl(0, TCSETAF, &tbuf);
  1327. #else
  1328.    result = ioctl(0, TIOCSETP, &tbuf);
  1329. #endif 
  1330.    if (result == -1)
  1331.       return (errno);
  1332.  
  1333.    return (0);
  1334. }  /* end kbd_raw() */
  1335.  
  1336.  
  1337.  
  1338. /***************************************************************** KBD_RESTORE
  1339. ** This function is used to put the keyboard back in the
  1340. ** mode it was in before kbk_raw was called.  Note that
  1341. ** kbk_raw() must have been called at least once before
  1342. ** kbd_restore() is called.
  1343. */
  1344.  
  1345. int
  1346. kbd_restore() {
  1347.    int result;
  1348.  
  1349.    /* Set keyboard termio to original mode */
  1350. #ifdef HAVE_TERMIO
  1351.    result = ioctl(0, TCSETAF, &kbd_tbuf);
  1352. #else
  1353.    result = ioctl(0, TIOCGETP, &kbd_tbuf);
  1354. #endif
  1355.  
  1356.    if (result == -1)
  1357.       return (errno);
  1358.  
  1359.    return(0);
  1360. }  /* end kbd_cooked() */
  1361.  
  1362.  
  1363. /*****************************************************************************/ 
  1364. /* Fetch a single register indicatated by 'regno'. 
  1365.  * Returns 0/-1 on success/failure.  
  1366.  */
  1367. static int
  1368. fetch_register (regno)
  1369.      int regno;
  1370. {
  1371.      int  result;
  1372.   DENTER("mm_fetch_register()");
  1373.   out_msg_buf->read_req_msg.code= READ_REQ;
  1374.   out_msg_buf->read_req_msg.length = 4*3;
  1375.   out_msg_buf->read_req_msg.byte_count = 4;
  1376.  
  1377.   if (regno == GR1_REGNUM)
  1378.   { out_msg_buf->read_req_msg.memory_space = GLOBAL_REG;
  1379.     out_msg_buf->read_req_msg.address = 1;
  1380.   }
  1381.   else if (regno >= GR96_REGNUM && regno < GR96_REGNUM + 32)
  1382.   { out_msg_buf->read_req_msg.memory_space = GLOBAL_REG;
  1383.     out_msg_buf->read_req_msg.address = (regno - GR96_REGNUM) + 96;
  1384.   }
  1385. #if defined(GR64_REGNUM)
  1386.   else if (regno >= GR64_REGNUM && regno < GR64_REGNUM + 32 )
  1387.   { out_msg_buf->read_req_msg.memory_space = GLOBAL_REG;
  1388.     out_msg_buf->read_req_msg.address = (regno - GR64_REGNUM) + 64;
  1389.   }
  1390. #endif    /* GR64_REGNUM */
  1391.   else if (regno >= LR0_REGNUM && regno < LR0_REGNUM + 128)
  1392.   { out_msg_buf->read_req_msg.memory_space = LOCAL_REG;
  1393.     out_msg_buf->read_req_msg.address = (regno - LR0_REGNUM);
  1394.   }
  1395.   else if (regno>=FPE_REGNUM && regno<=EXO_REGNUM)  
  1396.   { int val = -1;
  1397.     supply_register(160 + (regno - FPE_REGNUM),&val);
  1398.     return 0;        /* Pretend Success */
  1399.   }
  1400.   else 
  1401.   { out_msg_buf->read_req_msg.memory_space = SPECIAL_REG;
  1402.     out_msg_buf->read_req_msg.address = regnum_to_srnum(regno); 
  1403.   } 
  1404.  
  1405.   msg_send_serial(out_msg_buf);
  1406.  
  1407.   if (expect_msg(READ_ACK,in_msg_buf,1)) {
  1408.       supply_register (regno, &(in_msg_buf->read_r_ack_msg.data[0]));
  1409.     result = 0;
  1410.   } else {
  1411.     result = -1;
  1412.   }
  1413.   DEXIT("mm_fetch_register()");
  1414.   return result;
  1415. }
  1416. /*****************************************************************************/ 
  1417. /* Store a single register indicated by 'regno'. 
  1418.  * Returns 0/-1 on success/failure.  
  1419.  */
  1420. static int
  1421. store_register (regno)
  1422.      int regno;
  1423. {
  1424.      int  result;
  1425.  
  1426.   DENTER("store_register()");
  1427.   out_msg_buf->write_req_msg.code= WRITE_REQ;
  1428.   out_msg_buf->write_req_msg.length = 4*4;
  1429.   out_msg_buf->write_req_msg.byte_count = 4;
  1430.   out_msg_buf->write_r_msg.data[0] = read_register (regno);
  1431.  
  1432.   if (regno == GR1_REGNUM)
  1433.   { out_msg_buf->write_req_msg.memory_space = GLOBAL_REG;
  1434.     out_msg_buf->write_req_msg.address = 1;
  1435.     /* Setting GR1 changes the numbers of all the locals, so invalidate the 
  1436.      * register cache.  Do this *after* calling read_register, because we want 
  1437.      * read_register to return the value that write_register has just stuffed 
  1438.      * into the registers array, not the value of the register fetched from 
  1439.      * the inferior.  
  1440.      */
  1441.     registers_changed ();
  1442.   }
  1443. #if defined(GR64_REGNUM)
  1444.   else if (regno >= GR64_REGNUM && regno < GR64_REGNUM + 32 )
  1445.   { out_msg_buf->write_req_msg.memory_space = GLOBAL_REG;
  1446.     out_msg_buf->write_req_msg.address = (regno - GR64_REGNUM) + 64;
  1447.   }
  1448. #endif    /* GR64_REGNUM */
  1449.   else if (regno >= GR96_REGNUM && regno < GR96_REGNUM + 32)
  1450.   { out_msg_buf->write_req_msg.memory_space = GLOBAL_REG;
  1451.     out_msg_buf->write_req_msg.address = (regno - GR96_REGNUM) + 96;
  1452.   }
  1453.   else if (regno >= LR0_REGNUM && regno < LR0_REGNUM + 128)
  1454.   { out_msg_buf->write_req_msg.memory_space = LOCAL_REG;
  1455.     out_msg_buf->write_req_msg.address = (regno - LR0_REGNUM);
  1456.   }
  1457.   else if (regno>=FPE_REGNUM && regno<=EXO_REGNUM)  
  1458.   { 
  1459.     return 0;        /* Pretend Success */
  1460.   }
  1461.   else     /* An unprotected or protected special register */
  1462.   { out_msg_buf->write_req_msg.memory_space = SPECIAL_REG;
  1463.     out_msg_buf->write_req_msg.address = regnum_to_srnum(regno); 
  1464.   } 
  1465.  
  1466.   msg_send_serial(out_msg_buf);
  1467.  
  1468.   if (expect_msg(WRITE_ACK,in_msg_buf,1)) {
  1469.     result = 0;
  1470.   } else {
  1471.     result = -1;
  1472.   }
  1473.   DEXIT("store_register()");
  1474.   return result;
  1475. }
  1476. /****************************************************************************/
  1477. /* 
  1478.  * Convert a gdb special register number to a 29000 special register number.
  1479.  */
  1480. static int
  1481. regnum_to_srnum(regno)
  1482. int    regno;
  1483. {
  1484.     switch(regno) {
  1485.         case VAB_REGNUM: return(0); 
  1486.         case OPS_REGNUM: return(1); 
  1487.         case CPS_REGNUM: return(2); 
  1488.         case CFG_REGNUM: return(3); 
  1489.         case CHA_REGNUM: return(4); 
  1490.         case CHD_REGNUM: return(5); 
  1491.         case CHC_REGNUM: return(6); 
  1492.         case RBP_REGNUM: return(7); 
  1493.         case TMC_REGNUM: return(8); 
  1494.         case TMR_REGNUM: return(9); 
  1495.         case NPC_REGNUM: return(USE_SHADOW_PC ? (20) : (10));
  1496.         case PC_REGNUM:  return(USE_SHADOW_PC ? (21) : (11));
  1497.         case PC2_REGNUM: return(USE_SHADOW_PC ? (22) : (12));
  1498.         case MMU_REGNUM: return(13); 
  1499.         case LRU_REGNUM: return(14); 
  1500.         case IPC_REGNUM: return(128); 
  1501.         case IPA_REGNUM: return(129); 
  1502.         case IPB_REGNUM: return(130); 
  1503.         case Q_REGNUM:   return(131); 
  1504.         case ALU_REGNUM: return(132); 
  1505.         case BP_REGNUM:  return(133); 
  1506.         case FC_REGNUM:  return(134); 
  1507.         case CR_REGNUM:  return(135); 
  1508.         case FPE_REGNUM: return(160); 
  1509.         case INT_REGNUM: return(161); 
  1510.         case FPS_REGNUM: return(162); 
  1511.         case EXO_REGNUM:return(164); 
  1512.         default:
  1513.             return(255);    /* Failure ? */
  1514.     }
  1515. }
  1516. /****************************************************************************/
  1517. /* 
  1518.  * Initialize the target debugger (minimon only).
  1519.  */
  1520. static void
  1521. init_target_mm(tstart,tend,dstart,dend,entry,ms_size,rs_size,arg_start)
  1522. ADDR32    tstart,tend,dstart,dend,entry;
  1523. INT32    ms_size,rs_size;
  1524. ADDR32    arg_start;
  1525. {
  1526.     out_msg_buf->init_msg.code = INIT;
  1527.     out_msg_buf->init_msg.length= sizeof(struct init_msg_t)-2*sizeof(INT32);
  1528.     out_msg_buf->init_msg.text_start = tstart;
  1529.     out_msg_buf->init_msg.text_end = tend;
  1530.     out_msg_buf->init_msg.data_start = dstart;
  1531.     out_msg_buf->init_msg.data_end = dend;
  1532.     out_msg_buf->init_msg.entry_point = entry;
  1533.     out_msg_buf->init_msg.mem_stack_size = ms_size;
  1534.     out_msg_buf->init_msg.reg_stack_size = rs_size;
  1535.     out_msg_buf->init_msg.arg_start = arg_start;
  1536.     msg_send_serial(out_msg_buf);
  1537.     expect_msg(INIT_ACK,in_msg_buf,1);
  1538. }
  1539. /****************************************************************************/
  1540. /* 
  1541.  * Return a pointer to a string representing the given message code.
  1542.  * Not all messages are represented here, only the ones that we expect
  1543.  * to be called with.
  1544.  */
  1545. static char*
  1546. msg_str(code)
  1547. INT32    code;
  1548. {
  1549.     static char cbuf[32];
  1550.  
  1551.     switch (code) {
  1552.     case BKPT_SET_ACK: sprintf(cbuf,"%s (%d)","BKPT_SET_ACK",code); break; 
  1553.     case BKPT_RM_ACK: sprintf(cbuf,"%s (%d)","BKPT_RM_ACK",code); break; 
  1554.     case INIT_ACK:       sprintf(cbuf,"%s (%d)","INIT_ACK",code); break; 
  1555.     case READ_ACK:       sprintf(cbuf,"%s (%d)","READ_ACK",code); break; 
  1556.     case WRITE_ACK:      sprintf(cbuf,"%s (%d)","WRITE_ACK",code); break; 
  1557.     case ERROR:       sprintf(cbuf,"%s (%d)","ERROR",code); break; 
  1558.     case HALT:     sprintf(cbuf,"%s (%d)","HALT",code); break; 
  1559.     default:    sprintf(cbuf,"UNKNOWN (%d)",code); break; 
  1560.     }
  1561.     return(cbuf);
  1562. }
  1563. /****************************************************************************/
  1564. /*
  1565.  * Selected (not all of them) error codes that we might get.
  1566.  */
  1567. static char* 
  1568. error_msg_str(code)
  1569. INT32    code;
  1570. {
  1571.     static char cbuf[50];
  1572.  
  1573.     switch (code) {
  1574.     case EMFAIL:     return("EMFAIL: unrecoverable error"); 
  1575.     case EMBADADDR: return("EMBADADDR: Illegal address"); 
  1576.     case EMBADREG:     return("EMBADREG: Illegal register "); 
  1577.     case EMACCESS:     return("EMACCESS: Could not access memory");
  1578.     case EMBADMSG:     return("EMBADMSG: Unknown message type"); 
  1579.     case EMMSG2BIG: return("EMMSG2BIG: Message to large"); 
  1580.     case EMNOSEND:     return("EMNOSEND: Could not send message"); 
  1581.     case EMNORECV:     return("EMNORECV: Could not recv message"); 
  1582.     case EMRESET:     return("EMRESET: Could not RESET target"); 
  1583.     case EMCONFIG:     return("EMCONFIG: Could not get target CONFIG"); 
  1584.     case EMSTATUS:     return("EMSTATUS: Could not get target STATUS"); 
  1585.     case EMREAD:     return("EMREAD: Could not READ target memory"); 
  1586.     case EMWRITE:     return("EMWRITE: Could not WRITE target memory"); 
  1587.     case EMBKPTSET: return("EMBKPTSET: Could not set breakpoint"); 
  1588.     case EMBKPTRM:    return("EMBKPTRM: Could not remove breakpoint"); 
  1589.     case EMBKPTSTAT:return("EMBKPTSTAT: Could not get breakpoint status"); 
  1590.     case EMBKPTNONE:return("EMBKPTNONE: All breakpoints in use"); 
  1591.     case EMBKPTUSED:return("EMBKPTUSED: Breakpoints already in use"); 
  1592.     case EMINIT:     return("EMINIT: Could not init target memory"); 
  1593.     case EMGO:     return("EMGO: Could not start execution"); 
  1594.     case EMSTEP:     return("EMSTEP: Could not single step"); 
  1595.     case EMBREAK:     return("EMBREAK: Could not BREAK"); 
  1596.     case EMCOMMERR: return("EMCOMMERR: Communication error"); 
  1597.     default:         sprintf(cbuf,"error number %d",code); break;
  1598.     } /* end switch */
  1599.  
  1600.     return (cbuf);
  1601. }
  1602. /****************************************************************************/
  1603. /* 
  1604.  *  Receive a message and expect it to be of type msgcode.
  1605.  *  Returns 0/1 on failure/success.
  1606.  */
  1607. static int
  1608. expect_msg(msgcode,msg_buf,from_tty)
  1609. INT32    msgcode;        /* Msg code we expect */
  1610. union msg_t *msg_buf;        /* Where to put  the message received */
  1611. int    from_tty;        /* Print message on error if non-zero */
  1612. {
  1613.   /* DENTER("expect_msg()"); */
  1614.   int    retries=0;
  1615.   while(msg_recv_serial(msg_buf) && (retries++<MAX_RETRIES)); 
  1616.   if (retries >= MAX_RETRIES) {
  1617.     printf("Expected msg %s, ",msg_str(msgcode));
  1618.     printf("no message received!\n");
  1619.         /* DEXIT("expect_msg() failure"); */
  1620.         return(0);        /* Failure */
  1621.   }
  1622.  
  1623.   if (msg_buf->generic_msg.code != msgcode) {
  1624.      if (from_tty) {
  1625.     printf("Expected msg %s, ",msg_str(msgcode));
  1626.     printf("got msg %s\n",msg_str(msg_buf->generic_msg.code));
  1627.         if (msg_buf->generic_msg.code == ERROR) 
  1628.         printf("%s\n",error_msg_str(msg_buf->error_msg.error_code));
  1629.      }
  1630.      /* DEXIT("expect_msg() failure"); */
  1631.      return(0);            /* Failure */
  1632.   }
  1633.   /* DEXIT("expect_msg() success"); */
  1634.   return(1);            /* Success */
  1635. }    
  1636. /****************************************************************************/
  1637. /*
  1638.  * Determine the MiniMon memory space qualifier based on the addr. 
  1639.  * FIXME: Can't distinguis I_ROM/D_ROM.  
  1640.  * FIXME: Doesn't know anything about I_CACHE/D_CACHE.
  1641.  */
  1642. static int
  1643. mm_memory_space(addr)
  1644. CORE_ADDR    *addr;
  1645. {
  1646.     ADDR32 tstart = target_config.I_mem_start;
  1647.     ADDR32 tend   = tstart + target_config.I_mem_size;  
  1648.     ADDR32 dstart = target_config.D_mem_start;
  1649.     ADDR32 dend   = tstart + target_config.D_mem_size;  
  1650.     ADDR32 rstart = target_config.ROM_start;
  1651.     ADDR32 rend   = tstart + target_config.ROM_size;  
  1652.  
  1653.     if (((ADDR32)addr >= tstart) && ((ADDR32)addr < tend)) { 
  1654.         return I_MEM;
  1655.     } else if (((ADDR32)addr >= dstart) && ((ADDR32)addr < dend)) { 
  1656.         return D_MEM;
  1657.     } else if (((ADDR32)addr >= rstart) && ((ADDR32)addr < rend)) {
  1658.         /* FIXME: how do we determine between D_ROM and I_ROM */
  1659.         return D_ROM;
  1660.     } else    /* FIXME: what do me do now? */
  1661.         return D_MEM;    /* Hmmm! */
  1662. }
  1663.  
  1664. /****************************************************************************/
  1665. /* 
  1666.  *  Define the target subroutine names 
  1667.  */
  1668. struct target_ops mm_ops = {
  1669.         "minimon", "Remote AMD/Minimon target",
  1670.     "Remote debug an AMD 290*0 using the MiniMon dbg core on the target",
  1671.         mm_open, mm_close,
  1672.         mm_attach, mm_detach, mm_resume, mm_wait,
  1673.         mm_fetch_registers, mm_store_registers,
  1674.         mm_prepare_to_store, 0, 0,   /* conv_to, conv_from */
  1675.         mm_xfer_inferior_memory,
  1676.         mm_files_info,
  1677.         mm_insert_breakpoint, mm_remove_breakpoint, /* Breakpoints */
  1678.         0, 0, 0, 0, 0,          /* Terminal handling */
  1679.         mm_kill,                 /* FIXME, kill */
  1680.         mm_load, 
  1681.         0,                      /* lookup_symbol */
  1682.         mm_create_inferior,  /* create_inferior */
  1683.         mm_mourn,            /* mourn_inferior FIXME */
  1684.         process_stratum, 0, /* next */
  1685.         1, 1, 1, 1, 1,  /* all mem, mem, stack, regs, exec */
  1686.     0,0,        /* sections, sections_end */
  1687.         OPS_MAGIC,              /* Always the last thing */
  1688. };
  1689.  
  1690. void
  1691. _initialize_remote_mm()
  1692. {
  1693.   add_target (&mm_ops);
  1694. }
  1695.  
  1696. #ifdef NO_HIF_SUPPORT
  1697. service_HIF(msg)
  1698. union msg_t    *msg;
  1699. {
  1700.     return(0);    /* Emulate a failure */
  1701. }
  1702. #endif
  1703.